{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quickstart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Contents**\n",
    "\n",
    "- [How to build a neuron model?](#How-to-build-a-neuron-model?)\n",
    "- [How to build a synapse model?](#How-to-build-a-synapse-model?)\n",
    "- [How to construct a network?](#How-to-construct-a-network?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two main functions are provided in BrainPy: **neurodynamics simulation** and **neurodynamics analysis**. In this part, I will focus on neuronal dynamics simulation, and tell you how to code a dynamical network in BrainPy bu using the example of *(Wang & Buzsáki, 1996)*.\n",
    "\n",
    "- Wang, Xiao-Jing, and György Buzsáki. \"Gamma oscillation by synaptic inhibition in a hippocampal interneuronal network model.\" Journal of neuroscience 16.20 (1996): 6402-6413.\n",
    "\n",
    "*(Wang & Buzsáki, 1996)* demonstrates how a group of neuron with mutual inhibition produce the gamma oscillation (20–80 Hz) observed in the neocortex and hippocampus. In this network model, the neurons are modeled as a variant of Hodgkin–Huxley (HH) neuron model, and the inhibition connections between neurons are modeled as the GABA<sub>A</sub> synapses.\n",
    "\n",
    "Here, we will first build a HH neuron model. Then, construct a GABA<sub>A</sub> synapse model. Finally, combining the HH model and GABA<sub>A</sub> moldel together, we will build a network model. We expect at the suitable parameter regions, the network will produce gamma oscillation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all, import your favorite ``brainpy`` and ``numpy`` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:19.496166Z",
     "start_time": "2020-12-29T09:41:17.303190Z"
    }
   },
   "outputs": [],
   "source": [
    "import brainpy as bp\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In BrainPy, all the system-level settings are implmented in ``bp.profile``. By using ``bp.profile``, you can set the backend or the device of the models going to run on, the method and the precision of the numerical integrator, etc. Before diving into this tutorial, let's set the necessary profiles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:20.149581Z",
     "start_time": "2020-12-29T09:41:20.144596Z"
    }
   },
   "outputs": [],
   "source": [
    "bp.profile.set(jit=True,\n",
    "               device='cpu',\n",
    "               dt=0.04,\n",
    "               numerical_method='exponential')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This setting means we will JIT compile our model on ``cpu`` device, the default numerical method is set to [exponential euler method](https://brainpy.readthedocs.io/en/latest/advanced/numerical_integrators.html) (``exponential``), and the numerical step is set to ``0.04``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to build a neuron model?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In BrainPy, the solving of differential equations is based on [numerical methods](https://brainpy.readthedocs.io/en/latest/advanced/numerical_integrators.html), such as Euler method, Runge–Kutta methods. Therefore, the definition of a neuron/synapse model is the definition of the *step functions* which explicitly point out how variable states at the current time $x(t)$ is converted to the next time $x(t+1)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take the neuron model as an example. \n",
    "\n",
    "To build a neuron model in BrainPy is to create an instance of ``NeuType``. The instantiation of ``NeuType`` requires three items:\n",
    "\n",
    "- *ST*: The neuron model state.\n",
    "- *steps*: The step function to update at each cycle of run.\n",
    "- *name* : The name of the neuron model (will be useful in error reporting and debugging)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are going to create a HH neuron model. The parameters of HH model are defined in the follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:22.837169Z",
     "start_time": "2020-12-29T09:41:22.831188Z"
    }
   },
   "outputs": [],
   "source": [
    "V_th = 0.  # the spike threshold\n",
    "C = 1.0  # the membrane capacitance\n",
    "gLeak = 0.1  # the conductance of leaky channel\n",
    "ELeak = -65  # the reversal potential of the leaky channel\n",
    "gNa = 35.  # the conductance of sodium channel\n",
    "ENa = 55.  # the reversal potential of sodium\n",
    "gK = 9.  # the conductance of potassium channel\n",
    "EK = -90.  # the reversal potential of potassium\n",
    "phi = 5.0  # the temperature depdendent scaling  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this variant of HH model, three dynamical variables ($V$, $h$ and $n$) exist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Coding the differential equations**\n",
    "\n",
    "For any [ordinary differential equation](https://brainpy.readthedocs.io/en/latest/advanced/differential_equations.html)\n",
    "\n",
    "$$\n",
    "{dx \\over dt} = f(x, t)\n",
    "$$\n",
    "\n",
    "you only need write down the right-hand part of the differential equations $f(x, t)$. By adding a powerfull decorator porovided by BrainPy, ``@bp.integrate``, the framework will automatically numerically integrate the defined equations. Generally, an ordinary differential equation in BrainPy can be coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:22:26.554214Z",
     "start_time": "2020-12-29T09:22:26.549230Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def func(x, t, other_arguments):\n",
    "    # ... some computation ...\n",
    "    dxdt = ...\n",
    "    return dxdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``@bp.integrate`` receives ``method`` keyword to specify the numerical method you want to choose. For example, adding ``@bp.integrate(method='rk4')`` means you integrate the decorated function by using Fouth-order Runge–Kutta method (The full list of supportted numerical integrators please see the document of [Numerical integrators](https://brainpy.readthedocs.io/en/latest/guides/numerical_integrators.html)). Otherwise, the differential function will be integrated by the system default method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specifically, for **h channel**,\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "{\\frac {dh}{dt}} &=\\alpha _{h}(V)(1-h)-\\beta _{h}(V)h \\\\\n",
    "\\alpha_h(V) &= 0.07 \\cdot \\exp\\big(-{V+58 \\over 20}\\big) \\\\\n",
    "\\beta_h(V) &= {1 \\over 1 + \\exp\\big(-{V+28\\over 10}\\big)}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "you can code it like this with BrainPy: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:25.736424Z",
     "start_time": "2020-12-29T09:41:25.604764Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_h(h, t, V):\n",
    "    alpha = 0.07 * np.exp(-(V + 58) / 20)\n",
    "    beta = 1 / (np.exp(-0.1 * (V + 28)) + 1)\n",
    "    dhdt = alpha * (1 - h) - beta * h\n",
    "    return phi * dhdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The differential equation of **n channel**\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "{\\frac {dn}{dt}} &=\\alpha _{n}(V)(1-n)-\\beta _{n}(V)n \\\\\n",
    "\\alpha_n(V) &= {0.01 \\cdot (V+34) \\over 1-\\exp\\big(-{V+34 \\over10}\\big)} \\\\\n",
    "\\beta_n(V) &= 0.125 \\cdot \\exp\\big(-{V+44 \\over 80}\\big)\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "can be coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:28.240718Z",
     "start_time": "2020-12-29T09:41:28.052217Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_n(n, t, V):\n",
    "    alpha = -0.01 * (V + 34) / (np.exp(-0.1 * (V + 34)) - 1)\n",
    "    beta = 0.125 * np.exp(-(V + 44) / 80)\n",
    "    dndt = alpha * (1 - n) - beta * n\n",
    "    return phi * dndt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the differential equation of **membrane potential V** is expressed as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "C_{m}{\\frac {d V}{dt}}&=-{\\bar {g}}_{\\text{K}}n^{4}(V-V_{K}) - {\\bar {g}}_{\\text{Na}}m^{3}h(V-V_{Na}) -{\\bar {g}}_{l}(V-V_{l}) + I_{syn}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $m$ is modeled as an instaneous channel (fast enough and substituted by its steady-state function)\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\alpha_m(V) &= {0.1 (V+ 40) \\over 1-\\exp\\big(-{ V+40 \\over 10}\\big)} \\\\\n",
    "\\beta_m(V) &= 4.0 \\cdot \\exp\\big(-{V+65 \\over 18}\\big) \\\\\n",
    "m &= {\\alpha_m(V) \\over \\alpha_m(V) + \\beta_m(V)}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Therefore, the differential equations of $V$ is coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:30.815501Z",
     "start_time": "2020-12-29T09:41:30.478242Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_V(V, t, h, n, Isyn):\n",
    "    m_alpha = -0.1 * (V + 35) / (np.exp(-0.1 * (V + 35)) - 1)\n",
    "    m_beta = 4 * np.exp(-(V + 60) / 18)\n",
    "    m = m_alpha / (m_alpha + m_beta)\n",
    "    INa = gNa * m ** 3 * h * (V - ENa)\n",
    "    IK = gK * n ** 4 * (V - EK)\n",
    "    IL = gLeak * (V - ELeak)\n",
    "    dvdt = (- INa - IK - IL + Isyn) / C\n",
    "    return dvdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Neuron state**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to support the convenient state management, BrainPy provides ``NeuState`` to help you manage your model state. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In HH neuron, there are $V$, $h$ and $n$ dynamical variables. Moreover, we can add a ``input`` item in HH neuron state to receive the varying input. Further, the neuron ``spike`` is also we take care of. So, the neuron state of HH model can be specified as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:32.650422Z",
     "start_time": "2020-12-29T09:41:32.643441Z"
    }
   },
   "outputs": [],
   "source": [
    "HH_ST = bp.types.NeuState(\n",
    "    V=-55.,  # membrane potential, default initial value is -55.\n",
    "    h=0.,  # h channel, default initial value is 0.\n",
    "    n=0.,  # n channel, default initial value is 0.\n",
    "    spike=0.,  # neuron spike state, default initial value is 0., \n",
    "                  # if neuron emits a spike, it will be 1.\n",
    "    input=0.  # neuron synaptic input, default initial value is 0.\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The instantiation of ``bp.types.NeuState`` can receive strings (`*args`), or ``key=value`` pairs (`**kwargs`). It can also be instantiated by a dict (which means the fields and their default initial values), or a list/tuple of fields (in this case the default initial value will be set to 0.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step functions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each model, the most important thing is to define the step functions. After the definition of differential equations, the step function of the HH model can be defined as: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:34.557323Z",
     "start_time": "2020-12-29T09:41:34.549342Z"
    }
   },
   "outputs": [],
   "source": [
    "def update(ST, _t):\n",
    "    h = int_h(ST['h'], _t, ST['V'])\n",
    "    n = int_n(ST['n'], _t, ST['V'])\n",
    "    V = int_V(ST['V'], _t, ST['h'], ST['n'], ST['input'])\n",
    "    spike = np.logical_and(ST['V'] < V_th, V >= V_th)\n",
    "    ST['spike'] = spike\n",
    "    ST['V'] = V\n",
    "    ST['h'] = h\n",
    "    ST['n'] = n\n",
    "    ST['input'] = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To define a step function, you can pass any data you need into the function as the functional arguments. The order of the arguments in each step function can be arbitrary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In HH model step function, as you can see, two arguments are required:\n",
    "\n",
    "- ``ST``: the neuron state.\n",
    "- ``_t``: the current time, which is a system keyword, and denotes the current time point. In BrainPy, there are three system keywords: ``_t``, ``_i`` (the current running step number), and ``_dt`` (the numerical integration precision)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NeuType**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, putting the above together, we get our HH neuron model as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:37.598795Z",
     "start_time": "2020-12-29T09:41:37.590817Z"
    }
   },
   "outputs": [],
   "source": [
    "HH = bp.NeuType(ST=HH_ST, name='HH_neuron', steps=update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More advanced usage of ``NeuType`` definition please see [Build Neurons](https://brainpy.readthedocs.io/en/latest/tutorials/build_neurons.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to build a synapse model?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the ``NeuType`` definition, let's announce the parameters all we need in the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:39.286279Z",
     "start_time": "2020-12-29T09:41:39.282291Z"
    }
   },
   "outputs": [],
   "source": [
    "g_max = 0.1  # the maximal synaptic conductance\n",
    "E = -75.  # the reversal potential\n",
    "alpha = 12.  # the channel opening rate\n",
    "beta = 0.1  # the channel closing rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The GABA<sub>A</sub> synapse defined in *(Wang & Buzsáki, 1996)* is mathematically expressed as "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "\\frac{ds}{dt} &= \\alpha F(V_{pre})(1-s)-\\beta s   \\quad (1) \\\\\n",
    "F(V_{pre}) &= {1 \\over 1+\\exp\\left(-{V_{pre}- V_{th} \\over 2}\\right)}  \\quad (2) \n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The synaptic current output onto the post-synaptic neuron is expressed as\n",
    "\n",
    "$$\n",
    "I_{ syn }=g_{max} s\\left(V-E\\right) \\quad (3)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, GABA<sub>A</sub> synapse model has one dynamical variable `s`. Thus, we can create the synapse state by using  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:41.633001Z",
     "start_time": "2020-12-29T09:41:41.628018Z"
    }
   },
   "outputs": [],
   "source": [
    "ST = bp.types.SynState('s')  # the initial (default) value is 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the equation (1) and (2), the state updating of GABA<sub>A</sub> synapse is coded as: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:43.040235Z",
     "start_time": "2020-12-29T09:41:43.006325Z"
    }
   },
   "outputs": [],
   "source": [
    "@bp.integrate\n",
    "def int_s(s, t, TT):\n",
    "    return alpha * TT * (1 - s) - beta * s\n",
    "\n",
    "def update(ST, _t, pre):\n",
    "    T = 1 / (1 + np.exp(-(pre['V'] - V_th) / 2))\n",
    "    s = int_s(ST['s'], _t, T)\n",
    "    ST['s'] = s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, based on the equation (3), the delayed synaptic value output onto the post-synaptic neurons of GABA<sub>A</sub> synpase can be coded as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:45.114684Z",
     "start_time": "2020-12-29T09:41:45.108700Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "@bp.delayed\n",
    "def output(ST, post):\n",
    "    post['input'] -= g_max * ST['s'] * (post['V'] - E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The decorator ``@bp.delayed`` can be added on the function which need the delayed ``ST``. BrainPy will automatically recognize the delayed fileds. For example, in this ``output()`` function, the field ``s`` will be automatically delayed. When calling ``output()``, the ``ST['s']`` will be the delayed one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, as you can see, in addition to `ST` and `_t`, the definition of the GABA<sub>A</sub> synapse requires ``pre`` and ``post`` (declared as function arguments in ``output()`` and ``update()``). \n",
    "If you use this model defined by yourself, you clearly know what data you need to run the model. However, when somebody use your defined model, they will be confused by what ``pre`` and ``post`` mean. So, here we can make type declarations (optional):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:46.910972Z",
     "start_time": "2020-12-29T09:41:46.904990Z"
    }
   },
   "outputs": [],
   "source": [
    "requires = dict(\n",
    "    pre=bp.types.NeuState(['V'], help='pre-synaptic neuron state'),\n",
    "    post=bp.types.NeuState(['V', 'input'], help='post-synaptic neuron state'),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which means this model need a pre-synaptic \"NeuState\" data `pre` (in which the field ``V`` is needed to compute the synapatic state) and  a post-synaptic \"NeuState\" `post` (in which the fields ``V`` and ``input`` are needed)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's put the above difinitions together, and we get our wantted synapse model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:48.073860Z",
     "start_time": "2020-12-29T09:41:48.062895Z"
    }
   },
   "outputs": [],
   "source": [
    "GABAa = bp.SynType(ST=ST,\n",
    "                   name='GABAa', \n",
    "                   steps=(update, output), \n",
    "                   requires=requires, \n",
    "                   mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to construct a network?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is worthy to note that the above defined ``HH`` NeuType and ``GABAa`` SynType are abstract models. They can not be used for concrete computation. Instead, we should define the ``NeuGroup`` and ``SynConn``. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, by using ``bp.NeuGroup``, let's define a neuron group which contains 100 neurons. At the same time, we monitor the history trajectory of membrane potential ``V`` and spikes ``spike``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:50.188204Z",
     "start_time": "2020-12-29T09:41:50.183217Z"
    }
   },
   "outputs": [],
   "source": [
    "num = 100\n",
    "neu = bp.NeuGroup(HH, geometry=num, monitors=['spike', 'V'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the concrete synaptic connection can be constructed by using ``bp.SynConn``. It receives an instance of SynType (argument ``model``), the pre-synaptic neuron group (argument ``pre_group``), the post-synaptic neuron group (argument ``post_group``), the connection methods between the two groups (argument ``conn``), and the delay length (argument ``delay``)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:53.494356Z",
     "start_time": "2020-12-29T09:41:53.121357Z"
    }
   },
   "outputs": [],
   "source": [
    "syn = bp.SynConn(model=GABAa, \n",
    "                 pre_group=neu, \n",
    "                 post_group=neu,\n",
    "                 conn=bp.connect.All2All(include_self=False),\n",
    "                 delay=0.5,\n",
    "                 monitors=['s'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial state value of a neuron group or an ensemble of synaptical connections can be updated by set ``neu_group.ST[key] = value``, or ``syn_conn.ST[key] = value``. In this example, we can update the initial value of ``neu`` as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:51.673229Z",
     "start_time": "2020-12-29T09:41:51.664254Z"
    }
   },
   "outputs": [],
   "source": [
    "v_init = -70. + np.random.random(num) * 20\n",
    "h_alpha = 0.07 * np.exp(-(v_init + 58) / 20)\n",
    "h_beta = 1 / (np.exp(-0.1 * (v_init + 28)) + 1)\n",
    "h_init = h_alpha / (h_alpha + h_beta)\n",
    "n_alpha = -0.01 * (v_init + 34) / (np.exp(-0.1 * (v_init + 34)) - 1)\n",
    "n_beta = 0.125 * np.exp(-(v_init + 44) / 80)\n",
    "n_init = n_alpha / (n_alpha + n_beta)\n",
    "\n",
    "neu.ST['V'] = v_init\n",
    "neu.ST['h'] = h_init\n",
    "neu.ST['n'] = n_init"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, the parameters of the created neuron groups or synaptical connections can be updated by using ``neu_group.pars[key] = value``, or ``syn_conn.pars[key] = value``. In this example, we can update the parameter of ``syn`` as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:41:54.410904Z",
     "start_time": "2020-12-29T09:41:54.406914Z"
    }
   },
   "outputs": [],
   "source": [
    "syn.pars['g_max'] = 0.1 / num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, by adding the created neuron groups and synapse connection into the ``bp.Network``, we get an instance of the network. Each ``bp.Network`` has a powerful function ``.run()``. You can specify the total duration to run (argument ``duration``), the inputs to various components (argument ``inputs``), and the option for progress reporting (arguments ``report`` and ``report_percent``). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:51:34.174420Z",
     "start_time": "2020-12-29T09:41:56.005637Z"
    }
   },
   "outputs": [],
   "source": [
    "net = bp.Network(neu, syn)\n",
    "net.run(duration=500., inputs=[neu, 'ST.input', 1.2], report=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize the network running results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-29T09:52:10.094494Z",
     "start_time": "2020-12-29T09:52:09.434039Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ts = net.ts\n",
    "fig, gs = bp.visualize.get_figure(2, 1, 3, 12)\n",
    "\n",
    "fig.add_subplot(gs[0, 0])\n",
    "plt.plot(ts, neu.mon.V[:, 0])\n",
    "plt.ylabel('Membrane potential (N0)')\n",
    "plt.xlim(net.t_start - 0.1, net.t_end + 0.1)\n",
    "\n",
    "fig.add_subplot(gs[1, 0])\n",
    "index, time = bp.measure.raster_plot(neu.mon.spike, net.ts)\n",
    "plt.plot(time, index, '.')\n",
    "plt.xlim(net.t_start - 0.1, net.t_end + 0.1)\n",
    "plt.xlabel('Time (ms)')\n",
    "plt.ylabel('Raster plot')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full file of this example model can be obtained in [gamma_oscillation](https://brainpy-models.readthedocs.io/en/latest/examples/from_papers/Wang_1996_gamma_oscillation.html)."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "151px",
    "width": "305px"
   },
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "279.273px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
